/* Copyright (c) 2007 Pentaho Corporation.  All rights reserved. 
 * This software was developed by Pentaho Corporation and is provided under the terms 
 * of the GNU Lesser General Public License, Version 2.1. You may not use 
 * this file except in compliance with the license. If you need a copy of the license, 
 * please go to http://www.gnu.org/licenses/lgpl-2.1.txt. The Original Code is Pentaho 
 * Data Integration.  The Initial Developer is Pentaho Corporation.
 *
 * Software distributed under the GNU Lesser Public License is distributed on an "AS IS" 
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or  implied. Please refer to 
 * the license for the specific language governing your rights and limitations.*/

/*
 * Created on 19-jun-2003
 *
 */

package org.pentaho.di.ui.job.entries.getpop;

import java.util.ArrayList;

import javax.mail.Folder;

import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CCombo;
import org.eclipse.swt.custom.CTabFolder;
import org.eclipse.swt.custom.CTabItem;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.events.ShellAdapter;
import org.eclipse.swt.events.ShellEvent;
import org.eclipse.swt.layout.FormAttachment;
import org.eclipse.swt.layout.FormData;
import org.eclipse.swt.layout.FormLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.DateTime;
import org.eclipse.swt.widgets.DirectoryDialog;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.MessageBox;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.pentaho.di.core.Const;
import org.pentaho.di.core.Props;
import org.pentaho.di.core.logging.LogChannel;
import org.pentaho.di.core.util.StringUtil;
import org.pentaho.di.i18n.BaseMessages;
import org.pentaho.di.job.JobMeta;
import org.pentaho.di.job.entries.getpop.JobEntryGetPOP;
import org.pentaho.di.job.entries.getpop.MailConnection;
import org.pentaho.di.job.entries.getpop.MailConnectionMeta;
import org.pentaho.di.job.entry.JobEntryDialogInterface;
import org.pentaho.di.job.entry.JobEntryInterface;
import org.pentaho.di.repository.Repository;
import org.pentaho.di.ui.core.gui.GUIResource;
import org.pentaho.di.ui.core.gui.WindowProperty;
import org.pentaho.di.ui.core.widget.TextVar;
import org.pentaho.di.ui.job.dialog.JobDialog;
import org.pentaho.di.ui.job.entry.JobEntryDialog;
import org.pentaho.di.ui.trans.step.BaseStepDialog;



/**
 * This dialog allows you to edit the Get POP job entry settings.
 * 
 * @author Matt
 * @since 19-06-2003
 */
public class JobEntryGetPOPDialog extends JobEntryDialog implements JobEntryDialogInterface
{
	private static Class<?> PKG = JobEntryGetPOP.class; // for i18n purposes, needed by Translator2!!   $NON-NLS-1$

	 private Label wlName;

	    private Text wName;

	    private FormData fdlName, fdName;

		private Label        wlServerName;
		private TextVar      wServerName;
		private FormData     fdlServerName, fdServerName;
		
		private Label        wlSender;
		private TextVar      wSender;
		private FormData     fdlSender, fdSender;
		
		private Label        wlReceipient;
		private TextVar      wReceipient;
		private FormData     fdlReceipient, fdReceipient;
		
		private Label        wlSubject;
		private TextVar      wSubject;
		private FormData     fdlSubject, fdSubject;

		private Label        wlBody;
		private TextVar      wBody;
		private FormData     fdlBody, fdBody;

		private Label        wlAttachmentFolder;
		private TextVar      wAttachmentFolder;
		private FormData     fdlAttachmentFolder, fdAttachmentFolder;
		private Button		wbAttachmentFolder;
		private FormData    fdbAttachmentFolder;
		
		private Label        wlAttachmentWildcard;
		private TextVar      wAttachmentWildcard;
		private FormData     fdlAttachmentWildcard, fdAttachmentWildcard;
		
		private Label        wlUserName;
		private TextVar      wUserName;
		private FormData     fdlUserName, fdUserName;
		
		private Label        wlIMAPFolder;
		private TextVar      wIMAPFolder;
		private FormData     fdlIMAPFolder, fdIMAPFolder;
		
		private Label        wlMoveToFolder;
		private TextVar      wMoveToFolder;
		private FormData     fdlMoveToFolder, fdMoveToFolder;
		private Button		wSelectMoveToFolder;
		private FormData	fdSelectMoveToFolder;
		private Button		wTestMoveToFolder;
		private FormData	fdTestMoveToFolder;
		
		private Label        wlPassword;
		private TextVar      wPassword;
		private FormData     fdlPassword, fdPassword;

		private Label        wlOutputDirectory;
		private TextVar      wOutputDirectory;
		private FormData     fdlOutputDirectory, fdOutputDirectory;

		private Label        wlFilenamePattern;
		private TextVar      wFilenamePattern;
		private FormData     fdlFilenamePattern, fdFilenamePattern;

		private Button       wbDirectory;
		private FormData     fdbDirectory;
		
		private Label wlListmails;
		private  CCombo wListmails;
		private FormData fdlListmails, fdListmails;
		
		private Label wlIMAPListmails;
		private  CCombo wIMAPListmails;
		private FormData fdlIMAPListmails, fdIMAPListmails;
		
		private Label wlAfterGetIMAP;
		private  CCombo wAfterGetIMAP;
		private FormData fdlAfterGetIMAP, fdAfterGetIMAP;

		private Label        wlFirstmails;
		private TextVar      wFirstmails;
		private FormData     fdlFirstmails, fdFirstmails;
		
		private Label        wlIMAPFirstmails;
		private TextVar      wIMAPFirstmails;
		private FormData     fdlIMAPFirstmails, fdIMAPFirstmails;

		
		private Label        wlPort;
		private TextVar      wPort;
		private FormData     fdlPort, fdPort;

		private Label        wlUseSSL;
		private Button       wUseSSL;
		private FormData     fdlUseSSL, fdUseSSL;
		
		private Label        wlUseProxy;
		private Button       wUseProxy;
		private FormData     fdlUseProxy, fdUseProxy;
		
		private Label        wlProxyUsername;
		private TextVar      wProxyUsername;
		private FormData     fdlProxyUsername, fdProxyUsername;

		
		private Label        wlIncludeSubFolders;
		private Button       wIncludeSubFolders;
		private FormData     fdlIncludeSubFolders, fdIncludeSubFolders;
		
		
		private Label        wlcreateMoveToFolder;
		private Button       wcreateMoveToFolder;
		private FormData     fdlcreateMoveToFolder, fdcreateMoveToFolder;
		
		private Label        wlcreateLocalFolder;
		private Button       wcreateLocalFolder;
		private FormData     fdlcreateLocalFolder, fdcreateLocalFolder;
		
		private Button       wNegateSender;
		private FormData     fdNegateSender;
		
		private Button       wNegateReceipient;
		private FormData     fdNegateReceipient;
		
		private Button       wNegateSubject;
		private FormData     fdNegateSubject;
		
		private Button       wNegateBody;
		private FormData     fdNegateBody;
		
		private Button       wNegateReceivedDate;
		private FormData     fdNegateReceivedDate;

		private Label        wlGetAttachment;
		private Button       wGetAttachment;
		private FormData     fdlGetAttachment, fdGetAttachment;
		
		private Label        wlGetMessage;
		private Button       wGetMessage;
		private FormData     fdlGetMessage, fdGetMessage;

		private Label        wlDifferentFolderForAttachment;
		private Button       wDifferentFolderForAttachment;
		private FormData     fdlDifferentFolderForAttachment, fdDifferentFolderForAttachment;
		
		private Label        wlPOP3Message;
		private FormData     fdlPOP3Message;
		
		private Label        wlDelete;
		private Button       wDelete;
		private FormData     fdlDelete, fdDelete;

	    private Button wOK, wCancel;

	    private Listener lsOK, lsCancel;

	    private JobEntryGetPOP jobEntry;

	    private Shell shell;

	    private SelectionAdapter lsDef;

	    private boolean changed;

		private CTabFolder   wTabFolder;
		private Composite    wGeneralComp, wSettingsComp, wSearchComp;	
		private CTabItem     wGeneralTab, wSettingsTab, wSearchTab;
		private FormData	 fdGeneralComp, fdSettingsComp, fdSearchComp;
		private FormData     fdTabFolder;
		
		private Group wServerSettings, wPOP3Settings, wIMAPSettings, wReceivedDate, wHeader, wContent;
	    private FormData fdServerSettings, fdPOP3Settings, fdIMAPSettings, fdReceivedDate, fdHeader, fdContent;
	    
		private Label        wlReadFrom;
		private TextVar      wReadFrom;
		private FormData     fdlReadFrom, fdReadFrom;
		private Button		open;
		
		private Label wlConditionOnReceivedDate;
		private CCombo wConditionOnReceivedDate;
		private FormData fdlConditionOnReceivedDate, fdConditionOnReceivedDate;
		
		private Label wlActionType;
		private CCombo wActionType;
		private FormData fdlActionType, fdActionType;
		
		private Label        wlReadTo;
		private TextVar      wReadTo;
		private FormData     fdlReadTo, fdReadTo;
		private Button		opento;
		
		private Group wTargetFolder;
	    private FormData fdTargetFolder;
	    
		private Label wlProtocol;
		private CCombo wProtocol;
		private FormData fdlProtocol, fdProtocol;
		
		private Button wTest;
		private FormData fdTest;
		private Listener lsTest;
		
		private Button wTestIMAPFolder;
		private FormData fdTestIMAPFolder;
		private Listener lsTestIMAPFolder;
		
		private Button wSelectFolder;
		private FormData fdSelectFolder;
		private Listener lsSelectFolder;
		
		private Listener lsTestMoveToFolder;
		private Listener lsSelectMoveToFolder;
		
		private MailConnection mailConn= null;
	    
	    public JobEntryGetPOPDialog(Shell parent, JobEntryInterface jobEntryInt, Repository rep, JobMeta jobMeta)
	    {
	        super(parent, jobEntryInt, rep, jobMeta);
	        jobEntry = (JobEntryGetPOP) jobEntryInt;
	        if (this.jobEntry.getName() == null)
	            this.jobEntry.setName(BaseMessages.getString(PKG, "JobGetPOP.Name.Default"));
	    }

	    public JobEntryInterface open()
	    {
	        Shell parent = getParent();
	        Display display = parent.getDisplay();

	        shell = new Shell(parent, props.getJobsDialogStyle());
	        props.setLook(shell);
	        JobDialog.setShellImage(shell, jobEntry);


	        ModifyListener lsMod = new ModifyListener()
	        {
	            public void modifyText(ModifyEvent e)
	            {
	            	closeMailConnection();
	                jobEntry.setChanged();
	            }
	        };

	    	SelectionListener lsSelection = new SelectionAdapter()
			{
				public void widgetSelected(SelectionEvent e) 
				{
					jobEntry.setChanged();
					closeMailConnection();
				}
			};
	        changed = jobEntry.hasChanged();

	        FormLayout formLayout = new FormLayout();
	        formLayout.marginWidth = Const.FORM_MARGIN;
	        formLayout.marginHeight = Const.FORM_MARGIN;

	        shell.setLayout(formLayout);
	        shell.setText(BaseMessages.getString(PKG, "JobGetPOP.Title"));

	        int middle = props.getMiddlePct();
	        int margin = Const.MARGIN;

	        // Filename line
	        wlName = new Label(shell, SWT.RIGHT);
	        wlName.setText(BaseMessages.getString(PKG, "JobGetPOP.Name.Label"));
	        props.setLook(wlName);
	        fdlName = new FormData();
	        fdlName.left = new FormAttachment(0, 0);
	        fdlName.right = new FormAttachment(middle, -margin);
	        fdlName.top = new FormAttachment(0, margin);
	        wlName.setLayoutData(fdlName);
	        wName = new Text(shell, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
	        props.setLook(wName);
	        wName.addModifyListener(lsMod);
	        fdName = new FormData();
	        fdName.left = new FormAttachment(middle, 0);
	        fdName.top = new FormAttachment(0, margin);
	        fdName.right = new FormAttachment(100, 0);
	        wName.setLayoutData(fdName);

	        wTabFolder = new CTabFolder(shell, SWT.BORDER);
	 		props.setLook(wTabFolder, Props.WIDGET_STYLE_TAB);
	 		
	 		//////////////////////////
			// START OF GENERAL TAB   ///
			//////////////////////////

			wGeneralTab=new CTabItem(wTabFolder, SWT.NONE);
			wGeneralTab.setText(BaseMessages.getString(PKG, "JobGetPOP.Tab.General.Label"));
			wGeneralComp = new Composite(wTabFolder, SWT.NONE);
	 		props.setLook(wGeneralComp);
			FormLayout generalLayout = new FormLayout();
			generalLayout.marginWidth  = 3;
			generalLayout.marginHeight = 3;
			wGeneralComp.setLayout(generalLayout);
			
		     // ////////////////////////
		     // START OF SERVER SETTINGS GROUP///
		     // /
		    wServerSettings = new Group(wGeneralComp, SWT.SHADOW_NONE);
		    props.setLook(wServerSettings);
		    wServerSettings.setText(BaseMessages.getString(PKG, "JobGetPOP.ServerSettings.Group.Label"));

		    FormLayout ServerSettingsgroupLayout = new FormLayout();
		    ServerSettingsgroupLayout.marginWidth = 10;
		    ServerSettingsgroupLayout.marginHeight = 10;
		    wServerSettings.setLayout(ServerSettingsgroupLayout);
			
			// ServerName line
			wlServerName=new Label(wServerSettings, SWT.RIGHT);
			wlServerName.setText(BaseMessages.getString(PKG, "JobGetPOP.Server.Label"));
			props.setLook(wlServerName);
			fdlServerName=new FormData();
			fdlServerName.left = new FormAttachment(0, 0);
			fdlServerName.top  = new FormAttachment(0, 2*margin);
			fdlServerName.right= new FormAttachment(middle, -margin);
			wlServerName.setLayoutData(fdlServerName);
			wServerName=new TextVar(jobMeta, wServerSettings, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wServerName);
			wServerName.addModifyListener(lsMod);
			fdServerName=new FormData();
			fdServerName.left = new FormAttachment(middle, 0);
			fdServerName.top  = new FormAttachment(0, 2*margin);
			fdServerName.right= new FormAttachment(100, 0);
			wServerName.setLayoutData(fdServerName);
			
			// USE connection with SSL
			wlUseSSL=new Label(wServerSettings, SWT.RIGHT);
			wlUseSSL.setText(BaseMessages.getString(PKG, "JobGetPOP.UseSSLMails.Label"));
			props.setLook(wlUseSSL);
			fdlUseSSL=new FormData();
			fdlUseSSL.left = new FormAttachment(0, 0);
			fdlUseSSL.top  = new FormAttachment(wServerName, margin);
			fdlUseSSL.right= new FormAttachment(middle, -margin);
			wlUseSSL.setLayoutData(fdlUseSSL);
			wUseSSL=new Button(wServerSettings, SWT.CHECK);
			props.setLook(wUseSSL);
			fdUseSSL=new FormData();
			wUseSSL.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.UseSSLMails.Tooltip"));
			fdUseSSL.left = new FormAttachment(middle, 0);
			fdUseSSL.top  = new FormAttachment(wServerName, margin);
			fdUseSSL.right= new FormAttachment(100, 0);
			wUseSSL.setLayoutData(fdUseSSL);

			wUseSSL.addSelectionListener(new SelectionAdapter() 
			{
				public void widgetSelected(SelectionEvent e) 
				{
					closeMailConnection();
					refreshPort(true);
				}
			}
			);

			// port
			wlPort=new Label(wServerSettings, SWT.RIGHT);
			wlPort.setText(BaseMessages.getString(PKG, "JobGetPOP.SSLPort.Label"));
			props.setLook(wlPort);
			fdlPort=new FormData();
			fdlPort.left = new FormAttachment(0, 0);
			fdlPort.top  = new FormAttachment(wUseSSL, margin);
			fdlPort.right= new FormAttachment(middle, -margin);
			wlPort.setLayoutData(fdlPort);
			wPort=new TextVar(jobMeta, wServerSettings, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wPort);
			wPort.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.SSLPort.Tooltip"));
			wPort.addModifyListener(lsMod);
			fdPort=new FormData();
			fdPort.left = new FormAttachment(middle, 0);
			fdPort.top  = new FormAttachment(wUseSSL, margin);
			fdPort.right= new FormAttachment(100, 0);
			wPort.setLayoutData(fdPort);



			// UserName line
			wlUserName=new Label(wServerSettings, SWT.RIGHT);
			wlUserName.setText(BaseMessages.getString(PKG, "JobGetPOP.Username.Label"));
			props.setLook(wlUserName);
			fdlUserName=new FormData();
			fdlUserName.left = new FormAttachment(0, 0);
			fdlUserName.top  = new FormAttachment(wPort, margin);
			fdlUserName.right= new FormAttachment(middle, -margin);
			wlUserName.setLayoutData(fdlUserName);
			wUserName=new TextVar(jobMeta, wServerSettings, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wUserName);
			wUserName.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.Username.Tooltip"));
			wUserName.addModifyListener(lsMod);
			fdUserName=new FormData();
			fdUserName.left = new FormAttachment(middle, 0);
			fdUserName.top  = new FormAttachment(wPort, margin);
			fdUserName.right= new FormAttachment(100, 0);
			wUserName.setLayoutData(fdUserName);


			// Password line
			wlPassword=new Label(wServerSettings, SWT.RIGHT);
			wlPassword.setText(BaseMessages.getString(PKG, "JobGetPOP.Password.Label"));
			props.setLook(wlPassword);
			fdlPassword=new FormData();
			fdlPassword.left = new FormAttachment(0, 0);
			fdlPassword.top  = new FormAttachment(wUserName, margin);
			fdlPassword.right= new FormAttachment(middle, -margin);
			wlPassword.setLayoutData(fdlPassword);
			wPassword=new TextVar(jobMeta, wServerSettings, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wPassword);
			wPassword.setEchoChar('*');
			wPassword.addModifyListener(lsMod);
			fdPassword=new FormData();
			fdPassword.left = new FormAttachment(middle, 0);
			fdPassword.top  = new FormAttachment(wUserName, margin);
			fdPassword.right= new FormAttachment(100, 0);
			wPassword.setLayoutData(fdPassword);

			// OK, if the password contains a variable, we don't want to have the password hidden...
			wPassword.getTextWidget().addModifyListener(new ModifyListener()
			{
				public void modifyText(ModifyEvent e)
				{
					checkPasswordVisible();
				}
			});
			
			// USE proxy
			wlUseProxy=new Label(wServerSettings, SWT.RIGHT);
			wlUseProxy.setText(BaseMessages.getString(PKG, "JobGetPOP.UseProxyMails.Label"));
			props.setLook(wlUseProxy);
			fdlUseProxy=new FormData();
			fdlUseProxy.left = new FormAttachment(0, 0);
			fdlUseProxy.top  = new FormAttachment(wPassword, 2*margin);
			fdlUseProxy.right= new FormAttachment(middle, -margin);
			wlUseProxy.setLayoutData(fdlUseProxy);
			wUseProxy=new Button(wServerSettings, SWT.CHECK);
			props.setLook(wUseProxy);
			fdUseProxy=new FormData();
			wUseProxy.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.UseProxyMails.Tooltip"));
			fdUseProxy.left = new FormAttachment(middle, 0);
			fdUseProxy.top  = new FormAttachment(wPassword, 2*margin);
			fdUseProxy.right= new FormAttachment(100, 0);
			wUseProxy.setLayoutData(fdUseProxy);

			wUseProxy.addSelectionListener(new SelectionAdapter() 
			{
				public void widgetSelected(SelectionEvent e) 
				{
					setUserProxy();
					jobEntry.setChanged();
				}
			}
			);
			
			// ProxyUsername line
			wlProxyUsername=new Label(wServerSettings, SWT.RIGHT);
			wlProxyUsername.setText(BaseMessages.getString(PKG, "JobGetPOP.ProxyUsername.Label"));
			props.setLook(wlProxyUsername);
			fdlProxyUsername=new FormData();
			fdlProxyUsername.left = new FormAttachment(0, 0);
			fdlProxyUsername.top  = new FormAttachment(wUseProxy, margin);
			fdlProxyUsername.right= new FormAttachment(middle, -margin);
			wlProxyUsername.setLayoutData(fdlProxyUsername);
			wProxyUsername=new TextVar(jobMeta, wServerSettings, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wProxyUsername);
			wProxyUsername.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.ProxyUsername.Tooltip"));
			wProxyUsername.addModifyListener(lsMod);
			fdProxyUsername=new FormData();
			fdProxyUsername.left = new FormAttachment(middle, 0);
			fdProxyUsername.top  = new FormAttachment(wUseProxy, margin);
			fdProxyUsername.right= new FormAttachment(100, 0);
			wProxyUsername.setLayoutData(fdProxyUsername);

			
		    //Protocol
		  	wlProtocol= new Label(wServerSettings, SWT.RIGHT);
		  	wlProtocol.setText(BaseMessages.getString(PKG, "JobGetPOP.Protocol.Label"));
		  	props.setLook(wlProtocol);
		  	fdlProtocol= new FormData();
		  	fdlProtocol.left = new FormAttachment(0, 0);
		  	fdlProtocol.right = new FormAttachment(middle, -margin);
		  	fdlProtocol.top = new FormAttachment(wProxyUsername, margin);
		  	wlProtocol.setLayoutData(fdlProtocol);
		  	wProtocol= new CCombo(wServerSettings, SWT.SINGLE | SWT.READ_ONLY | SWT.BORDER);
		  	wProtocol.setItems(MailConnectionMeta.protocolCodes);
		  	wProtocol.select(0);
			props.setLook(wProtocol);
			fdProtocol= new FormData();
			fdProtocol.left = new FormAttachment(middle, 0);
			fdProtocol.top = new FormAttachment(wProxyUsername, margin);
			fdProtocol.right = new FormAttachment(100, 0);
			wProtocol.setLayoutData(fdProtocol);
			wProtocol.addSelectionListener(new SelectionAdapter()
			{
				public void widgetSelected(SelectionEvent e)
				{
					refreshProtocal(true);
					
				}
			});

			// Test connection button
			wTest=new Button(wServerSettings,SWT.PUSH);
			wTest.setText(BaseMessages.getString(PKG, "JobGetPOP.TestConnection.Label"));
	 		props.setLook(wTest);
			fdTest=new FormData();
			wTest.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.TestConnection.Tooltip"));
			//fdTest.left = new FormAttachment(middle, 0);
			fdTest.top  = new FormAttachment(wProtocol, margin);
			fdTest.right= new FormAttachment(100, 0);
			wTest.setLayoutData(fdTest);
			
		    fdServerSettings = new FormData();
		    fdServerSettings.left = new FormAttachment(0, margin);
		    fdServerSettings.top = new FormAttachment(wProtocol, margin);
		    fdServerSettings.right = new FormAttachment(100, -margin);
		    wServerSettings.setLayoutData(fdServerSettings);
		    // ///////////////////////////////////////////////////////////
		    // / END OF SERVER SETTINGS GROUP
		    // ///////////////////////////////////////////////////////////
			
		     // ////////////////////////
		     // START OF Target Folder GROUP///
		     // /
		    wTargetFolder= new Group(wGeneralComp, SWT.SHADOW_NONE);
		    props.setLook(wTargetFolder);
		    wTargetFolder.setText(BaseMessages.getString(PKG, "JobGetPOP.TargetFolder.Group.Label"));

		    FormLayout TargetFoldergroupLayout = new FormLayout();
		    TargetFoldergroupLayout.marginWidth = 10;
		    TargetFoldergroupLayout.marginHeight = 10;
		    wTargetFolder.setLayout(TargetFoldergroupLayout);


			// OutputDirectory line
			wlOutputDirectory=new Label(wTargetFolder, SWT.RIGHT);
			wlOutputDirectory.setText(BaseMessages.getString(PKG, "JobGetPOP.OutputDirectory.Label"));
			props.setLook(wlOutputDirectory);
			fdlOutputDirectory=new FormData();
			fdlOutputDirectory.left = new FormAttachment(0, 0);
			fdlOutputDirectory.top  = new FormAttachment(wServerSettings, margin);
			fdlOutputDirectory.right= new FormAttachment(middle, -margin);
			wlOutputDirectory.setLayoutData(fdlOutputDirectory);
			
			// Browse Source folders button ...
			wbDirectory=new Button(wTargetFolder, SWT.PUSH| SWT.CENTER);
			props.setLook(wbDirectory);
			wbDirectory.setText(BaseMessages.getString(PKG, "JobGetPOP.BrowseFolders.Label"));
			fdbDirectory=new FormData();
			fdbDirectory.right= new FormAttachment(100, -margin);
			fdbDirectory.top  = new FormAttachment(wServerSettings, margin);
			wbDirectory.setLayoutData(fdbDirectory);
			
			wbDirectory.addSelectionListener
			(
				new SelectionAdapter()
				{
					public void widgetSelected(SelectionEvent e)
					{
						DirectoryDialog ddialog = new DirectoryDialog(shell, SWT.OPEN);
						if (wOutputDirectory.getText()!=null)
						{
							ddialog.setFilterPath(jobMeta.environmentSubstitute(wOutputDirectory.getText()) );
						}
						 // Calling open() will open and run the dialog.
				        // It will return the selected directory, or
				        // null if user cancels
				        String dir = ddialog.open();
				        if (dir != null) {
				          // Set the text box to the new selection
				        	wOutputDirectory.setText(dir);
				        }
						
					}
				}
			);
			
			wOutputDirectory=new TextVar(jobMeta, wTargetFolder, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wOutputDirectory);
			wOutputDirectory.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.OutputDirectory.Tooltip"));
			wOutputDirectory.addModifyListener(lsMod);
			fdOutputDirectory=new FormData();
			fdOutputDirectory.left = new FormAttachment(middle, 0);
			fdOutputDirectory.top  = new FormAttachment(wServerSettings, margin);
			fdOutputDirectory.right= new FormAttachment(wbDirectory, -margin);
			wOutputDirectory.setLayoutData(fdOutputDirectory);
			
			// Create local folder
			wlcreateLocalFolder=new Label(wTargetFolder, SWT.RIGHT);
			wlcreateLocalFolder.setText(BaseMessages.getString(PKG, "JobGetPOP.createLocalFolder.Label"));
			props.setLook(wlcreateLocalFolder);
			fdlcreateLocalFolder=new FormData();
			fdlcreateLocalFolder.left = new FormAttachment(0, 0);
			fdlcreateLocalFolder.top  = new FormAttachment(wOutputDirectory, margin);
			fdlcreateLocalFolder.right= new FormAttachment(middle, -margin);
			wlcreateLocalFolder.setLayoutData(fdlcreateLocalFolder);
			wcreateLocalFolder=new Button(wTargetFolder, SWT.CHECK);
			props.setLook(wcreateLocalFolder);
			fdcreateLocalFolder=new FormData();
			wcreateLocalFolder.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.createLocalFolder.Tooltip"));
			fdcreateLocalFolder.left = new FormAttachment(middle, 0);
			fdcreateLocalFolder.top  = new FormAttachment(wOutputDirectory, margin);
			fdcreateLocalFolder.right= new FormAttachment(100, 0);
			wcreateLocalFolder.setLayoutData(fdcreateLocalFolder);


			// Filename pattern line
			wlFilenamePattern=new Label(wTargetFolder, SWT.RIGHT);
			wlFilenamePattern.setText(BaseMessages.getString(PKG, "JobGetPOP.FilenamePattern.Label"));
			props.setLook(wlFilenamePattern);
			fdlFilenamePattern=new FormData();
			fdlFilenamePattern.left = new FormAttachment(0, 0);
			fdlFilenamePattern.top  = new FormAttachment(wcreateLocalFolder, margin);
			fdlFilenamePattern.right= new FormAttachment(middle, -margin);
			wlFilenamePattern.setLayoutData(fdlFilenamePattern);
			wFilenamePattern=new TextVar(jobMeta, wTargetFolder, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wFilenamePattern);
			wFilenamePattern.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.FilenamePattern.Tooltip"));
			wFilenamePattern.addModifyListener(lsMod);
			fdFilenamePattern=new FormData();
			fdFilenamePattern.left = new FormAttachment(middle, 0);
			fdFilenamePattern.top  = new FormAttachment(wcreateLocalFolder, margin);
			fdFilenamePattern.right= new FormAttachment(100, 0);
			wFilenamePattern.setLayoutData(fdFilenamePattern);

	        // Whenever something changes, set the tooltip to the expanded version:
	        wFilenamePattern.addModifyListener(new ModifyListener()
	        {
	            public void modifyText(ModifyEvent e)
	            {
	                wFilenamePattern.setToolTipText(jobMeta.environmentSubstitute(wFilenamePattern.getText()));
	            }
	        });
	        
	        // Get message?
			wlGetMessage=new Label(wTargetFolder, SWT.RIGHT);
			wlGetMessage.setText(BaseMessages.getString(PKG, "JobGetPOP.GetMessageMails.Label"));
			props.setLook(wlGetMessage);
			fdlGetMessage=new FormData();
			fdlGetMessage.left = new FormAttachment(0, 0);
			fdlGetMessage.top  = new FormAttachment(wFilenamePattern, margin);
			fdlGetMessage.right= new FormAttachment(middle, -margin);
			wlGetMessage.setLayoutData(fdlGetMessage);
			wGetMessage=new Button(wTargetFolder, SWT.CHECK);
			props.setLook(wGetMessage);
			fdGetMessage=new FormData();
			wGetMessage.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.GetMessageMails.Tooltip"));
			fdGetMessage.left = new FormAttachment(middle, 0);
			fdGetMessage.top  = new FormAttachment(wFilenamePattern, margin);
			fdGetMessage.right= new FormAttachment(100, 0);
			wGetMessage.setLayoutData(fdGetMessage);

			wGetMessage.addSelectionListener(new SelectionAdapter() 
			{
				public void widgetSelected(SelectionEvent e) 
				{
			    	if(!wGetAttachment.getSelection() && !wGetMessage.getSelection())
			    		wGetAttachment.setSelection(true);
				}
			}
			);

	        // Get attachment?
			wlGetAttachment=new Label(wTargetFolder, SWT.RIGHT);
			wlGetAttachment.setText(BaseMessages.getString(PKG, "JobGetPOP.GetAttachmentMails.Label"));
			props.setLook(wlGetAttachment);
			fdlGetAttachment=new FormData();
			fdlGetAttachment.left = new FormAttachment(0, 0);
			fdlGetAttachment.top  = new FormAttachment(wGetMessage, margin);
			fdlGetAttachment.right= new FormAttachment(middle, -margin);
			wlGetAttachment.setLayoutData(fdlGetAttachment);
			wGetAttachment=new Button(wTargetFolder, SWT.CHECK);
			props.setLook(wGetAttachment);
			fdGetAttachment=new FormData();
			wGetAttachment.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.GetAttachmentMails.Tooltip"));
			fdGetAttachment.left = new FormAttachment(middle, 0);
			fdGetAttachment.top  = new FormAttachment(wGetMessage, margin);
			fdGetAttachment.right= new FormAttachment(100, 0);
			wGetAttachment.setLayoutData(fdGetAttachment);

			wGetAttachment.addSelectionListener(new SelectionAdapter() 
			{
				public void widgetSelected(SelectionEvent e) 
				{
					activeAttachmentFolder();
				}
			}
			);

	        // different folder for attachment?
			wlDifferentFolderForAttachment=new Label(wTargetFolder, SWT.RIGHT);
			wlDifferentFolderForAttachment.setText(BaseMessages.getString(PKG, "JobGetPOP.DifferentFolderForAttachmentMails.Label"));
			props.setLook(wlDifferentFolderForAttachment);
			fdlDifferentFolderForAttachment=new FormData();
			fdlDifferentFolderForAttachment.left = new FormAttachment(0, 0);
			fdlDifferentFolderForAttachment.top  = new FormAttachment(wGetAttachment, margin);
			fdlDifferentFolderForAttachment.right= new FormAttachment(middle, -margin);
			wlDifferentFolderForAttachment.setLayoutData(fdlDifferentFolderForAttachment);
			wDifferentFolderForAttachment=new Button(wTargetFolder, SWT.CHECK);
			props.setLook(wDifferentFolderForAttachment);
			fdDifferentFolderForAttachment=new FormData();
			wDifferentFolderForAttachment.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.DifferentFolderForAttachmentMails.Tooltip"));
			fdDifferentFolderForAttachment.left = new FormAttachment(middle, 0);
			fdDifferentFolderForAttachment.top  = new FormAttachment(wGetAttachment, margin);
			fdDifferentFolderForAttachment.right= new FormAttachment(100, 0);
			wDifferentFolderForAttachment.setLayoutData(fdDifferentFolderForAttachment);

			wDifferentFolderForAttachment.addSelectionListener(new SelectionAdapter() 
			{
				public void widgetSelected(SelectionEvent e) 
				{
					activeAttachmentFolder();
				}
			}
			);
			

			// AttachmentFolder line
			wlAttachmentFolder=new Label(wTargetFolder, SWT.RIGHT);
			wlAttachmentFolder.setText(BaseMessages.getString(PKG, "JobGetPOP.AttachmentFolder.Label"));
			props.setLook(wlAttachmentFolder);
			fdlAttachmentFolder=new FormData();
			fdlAttachmentFolder.left = new FormAttachment(0, 0);
			fdlAttachmentFolder.top  = new FormAttachment(wDifferentFolderForAttachment, margin);
			fdlAttachmentFolder.right= new FormAttachment(middle, -margin);
			wlAttachmentFolder.setLayoutData(fdlAttachmentFolder);
			
			// Browse Source folders button ...
			wbAttachmentFolder=new Button(wTargetFolder, SWT.PUSH| SWT.CENTER);
			props.setLook(wbAttachmentFolder);
			wbAttachmentFolder.setText(BaseMessages.getString(PKG, "JobGetPOP.BrowseFolders.Label"));
			fdbAttachmentFolder=new FormData();
			fdbAttachmentFolder.right= new FormAttachment(100, -margin);
			fdbAttachmentFolder.top  = new FormAttachment(wDifferentFolderForAttachment, margin);
			wbAttachmentFolder.setLayoutData(fdbAttachmentFolder);
			
			wbAttachmentFolder.addSelectionListener
			(
				new SelectionAdapter()
				{
					public void widgetSelected(SelectionEvent e)
					{
						DirectoryDialog ddialog = new DirectoryDialog(shell, SWT.OPEN);
						if (wAttachmentFolder.getText()!=null)
						{
							ddialog.setFilterPath(jobMeta.environmentSubstitute(wAttachmentFolder.getText()) );
						}
						 // Calling open() will open and run the dialog.
				        // It will return the selected directory, or
				        // null if user cancels
				        String dir = ddialog.open();
				        if (dir != null) {
				          // Set the text box to the new selection
				        	wAttachmentFolder.setText(dir);
				        }
						
					}
				}
			);
			
			wAttachmentFolder=new TextVar(jobMeta, wTargetFolder, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wAttachmentFolder);
			wAttachmentFolder.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.AttachmentFolder.Tooltip"));
			wAttachmentFolder.addModifyListener(lsMod);
			fdAttachmentFolder=new FormData();
			fdAttachmentFolder.left = new FormAttachment(middle, 0);
			fdAttachmentFolder.top  = new FormAttachment(wDifferentFolderForAttachment, margin);
			fdAttachmentFolder.right= new FormAttachment(wbAttachmentFolder, -margin);
			wAttachmentFolder.setLayoutData(fdAttachmentFolder);
			
			// Limit attached files
			wlAttachmentWildcard=new Label(wTargetFolder, SWT.RIGHT);
			wlAttachmentWildcard.setText(BaseMessages.getString(PKG, "JobGetPOP.AttachmentWildcard.Label"));
			props.setLook(wlAttachmentWildcard);
			fdlAttachmentWildcard=new FormData();
			fdlAttachmentWildcard.left = new FormAttachment(0, 0);
			fdlAttachmentWildcard.top  = new FormAttachment(wbAttachmentFolder, margin);
			fdlAttachmentWildcard.right= new FormAttachment(middle, -margin);
			wlAttachmentWildcard.setLayoutData(fdlAttachmentWildcard);
			wAttachmentWildcard=new TextVar(jobMeta, wTargetFolder, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wAttachmentWildcard);
			wAttachmentWildcard.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.AttachmentWildcard.Tooltip"));
			wAttachmentWildcard.addModifyListener(lsMod);
			fdAttachmentWildcard=new FormData();
			fdAttachmentWildcard.left = new FormAttachment(middle, 0);
			fdAttachmentWildcard.top  = new FormAttachment(wbAttachmentFolder, margin);
			fdAttachmentWildcard.right= new FormAttachment(100, 0);
			wAttachmentWildcard.setLayoutData(fdAttachmentWildcard);

	        // Whenever something changes, set the tooltip to the expanded version:
	        wAttachmentWildcard.addModifyListener(new ModifyListener()
	        {
	            public void modifyText(ModifyEvent e)
	            {
	                wAttachmentWildcard.setToolTipText(jobMeta.environmentSubstitute(wAttachmentWildcard.getText()));
	            }
	        });
			
		    fdTargetFolder= new FormData();
		    fdTargetFolder.left = new FormAttachment(0, margin);
		    fdTargetFolder.top = new FormAttachment(wServerSettings, margin);
		    fdTargetFolder.right = new FormAttachment(100, -margin);
		    wTargetFolder.setLayoutData(fdTargetFolder);
		    // ///////////////////////////////////////////////////////////
		    // / END OF SERVER SETTINGS GROUP
		    // ///////////////////////////////////////////////////////////
		    
		    
			fdGeneralComp=new FormData();
			fdGeneralComp.left  = new FormAttachment(0, 0);
			fdGeneralComp.top   = new FormAttachment(wName, 0);
			fdGeneralComp.right = new FormAttachment(100, 0);
			fdGeneralComp.bottom= new FormAttachment(100, 0);
			wGeneralComp.setLayoutData(fdGeneralComp);
			
			wGeneralComp.layout();
			wGeneralTab.setControl(wGeneralComp);
	 		props.setLook(wGeneralComp);
	 		
			/////////////////////////////////////////////////////////////
			/// END OF GENERAL TAB
			/////////////////////////////////////////////////////////////
			
	 		//////////////////////////
			// START OF SETTINGS TAB   ///
			//////////////////////////

			wSettingsTab=new CTabItem(wTabFolder, SWT.NONE);
			wSettingsTab.setText(BaseMessages.getString(PKG, "JobGetPOP.Tab.Pop.Label"));
			wSettingsComp = new Composite(wTabFolder, SWT.NONE);
	 		props.setLook(wSettingsComp);
			FormLayout PopLayout = new FormLayout();
			PopLayout.marginWidth  = 3;
			PopLayout.marginHeight = 3;
			wSettingsComp.setLayout(PopLayout);
			
			  //Action type
		  	wlActionType= new Label(wSettingsComp, SWT.RIGHT);
		  	wlActionType.setText(BaseMessages.getString(PKG, "JobGetPOP.ActionType.Label"));
		  	props.setLook(wlActionType);
		  	fdlActionType= new FormData();
		  	fdlActionType.left = new FormAttachment(0, 0);
		  	fdlActionType.right = new FormAttachment(middle, -margin);
		  	fdlActionType.top = new FormAttachment(0, 3*margin);
		  	wlActionType.setLayoutData(fdlActionType);
		  	
		  	wActionType= new CCombo(wSettingsComp, SWT.SINGLE | SWT.READ_ONLY | SWT.BORDER);
		  	wActionType.setItems(MailConnectionMeta.actionTypeDesc);
		  	wActionType.select(0); // +1: starts at -1
		  	
			props.setLook(wActionType);
			fdActionType= new FormData();
			fdActionType.left = new FormAttachment(middle, 0);
			fdActionType.top = new FormAttachment(0, 3*margin);
			fdActionType.right = new FormAttachment(100, 0);
			wActionType.setLayoutData(fdActionType);
			wActionType.addSelectionListener(new SelectionAdapter()
			{
				public void widgetSelected(SelectionEvent e)
				{
					setActionType();
					jobEntry.setChanged();
				}
			});

			// Message: for POP3, only INBOX folder is available!
			wlPOP3Message=new Label(wSettingsComp, SWT.RIGHT);
			wlPOP3Message.setText(BaseMessages.getString(PKG, "JobGetPOP.POP3Message.Label"));
			props.setLook(wlPOP3Message);
			fdlPOP3Message=new FormData();
			fdlPOP3Message.left = new FormAttachment(0, margin);
			fdlPOP3Message.top  = new FormAttachment(wActionType, 3*margin);
			wlPOP3Message.setLayoutData(fdlPOP3Message);
			wlPOP3Message.setForeground(GUIResource.getInstance().getColorOrange());
			
		     // ////////////////////////
		     // START OF POP3 Settings GROUP///
		     // /
		    wPOP3Settings= new Group(wSettingsComp, SWT.SHADOW_NONE);
		    props.setLook(wPOP3Settings);
		    wPOP3Settings.setText(BaseMessages.getString(PKG, "JobGetPOP.POP3Settings.Group.Label"));

		    FormLayout POP3SettingsgroupLayout = new FormLayout();
		    POP3SettingsgroupLayout.marginWidth = 10;
		    POP3SettingsgroupLayout.marginHeight = 10;
		    wPOP3Settings.setLayout(POP3SettingsgroupLayout);

			// List of mails of retrieve
			wlListmails = new Label(wPOP3Settings, SWT.RIGHT);
			wlListmails.setText(BaseMessages.getString(PKG, "JobGetPOP.Listmails.Label"));
			props.setLook(wlListmails);
			fdlListmails = new FormData();
			fdlListmails.left = new FormAttachment(0, 0);
			fdlListmails.right = new FormAttachment(middle, 0);
			fdlListmails.top = new FormAttachment(wlPOP3Message, 2*margin);
			wlListmails.setLayoutData(fdlListmails);
			wListmails = new CCombo(wPOP3Settings, SWT.SINGLE | SWT.READ_ONLY | SWT.BORDER);
			wListmails.add(BaseMessages.getString(PKG, "JobGetPOP.RetrieveAllMails.Label"));
			wListmails.add(BaseMessages.getString(PKG, "JobGetPOP.RetrieveUnreadMails.Label"));
			wListmails.add(BaseMessages.getString(PKG, "JobGetPOP.RetrieveFirstMails.Label"));
			wListmails.select(0); // +1: starts at -1

			props.setLook(wListmails);
			fdListmails= new FormData();
			fdListmails.left = new FormAttachment(middle, 0);
			fdListmails.top = new FormAttachment(wlPOP3Message, 2*margin);
			fdListmails.right = new FormAttachment(100, 0);
			wListmails.setLayoutData(fdListmails);

			wListmails.addSelectionListener(new SelectionAdapter()
			{
				public void widgetSelected(SelectionEvent e)
				{
					jobEntry.setChanged();
					chooseListMails();
					
				}
			});


			// Retrieve the first ... mails
			wlFirstmails = new Label(wPOP3Settings, SWT.RIGHT);
			wlFirstmails.setText(BaseMessages.getString(PKG, "JobGetPOP.Firstmails.Label"));
			props.setLook(wlFirstmails);
			fdlFirstmails = new FormData();
			fdlFirstmails.left = new FormAttachment(0, 0);
			fdlFirstmails.right = new FormAttachment(middle, -margin);
			fdlFirstmails.top = new FormAttachment(wListmails, margin);
			wlFirstmails.setLayoutData(fdlFirstmails);

			wFirstmails = new TextVar(jobMeta, wPOP3Settings, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wFirstmails);
			wFirstmails.addModifyListener(lsMod);
			fdFirstmails = new FormData();
			fdFirstmails.left = new FormAttachment(middle, 0);
			fdFirstmails.top = new FormAttachment(wListmails, margin);
			fdFirstmails.right = new FormAttachment(100, 0);
			wFirstmails.setLayoutData(fdFirstmails);

			// Delete mails after retrieval...
			wlDelete=new Label(wPOP3Settings, SWT.RIGHT);
			wlDelete.setText(BaseMessages.getString(PKG, "JobGetPOP.DeleteMails.Label"));
			props.setLook(wlDelete);
			fdlDelete=new FormData();
			fdlDelete.left = new FormAttachment(0, 0);
			fdlDelete.top  = new FormAttachment(wFirstmails, margin);
			fdlDelete.right= new FormAttachment(middle, -margin);
			wlDelete.setLayoutData(fdlDelete);
			wDelete=new Button(wPOP3Settings, SWT.CHECK);
			props.setLook(wDelete);
			fdDelete=new FormData();
			wDelete.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.DeleteMails.Tooltip"));
			fdDelete.left = new FormAttachment(middle, 0);
			fdDelete.top  = new FormAttachment(wFirstmails, margin);
			fdDelete.right= new FormAttachment(100, 0);
			wDelete.setLayoutData(fdDelete);

		    fdPOP3Settings= new FormData();
		    fdPOP3Settings.left = new FormAttachment(0, margin);
		    fdPOP3Settings.top = new FormAttachment(wlPOP3Message, 2*margin);
		    fdPOP3Settings.right = new FormAttachment(100, -margin);
		    wPOP3Settings.setLayoutData(fdPOP3Settings);
		    // ///////////////////////////////////////////////////////////
		    // / END OF POP3 SETTINGS GROUP
		    // ///////////////////////////////////////////////////////////
			
		     // ////////////////////////
		     // START OF IMAP Settings GROUP///
		     // /
		    wIMAPSettings= new Group(wSettingsComp, SWT.SHADOW_NONE);
		    props.setLook(wIMAPSettings);
		    wIMAPSettings.setText(BaseMessages.getString(PKG, "JobGetPOP.IMAPSettings.Groupp.Label"));

		    FormLayout IMAPSettingsgroupLayout = new FormLayout();
		    IMAPSettingsgroupLayout.marginWidth = 10;
		    IMAPSettingsgroupLayout.marginHeight = 10;
		    wIMAPSettings.setLayout(IMAPSettingsgroupLayout);
		    
		    
			// SelectFolder button
			wSelectFolder=new Button(wIMAPSettings,SWT.PUSH);
			wSelectFolder.setText(BaseMessages.getString(PKG, "JobGetPOP.SelectFolderConnection.Label"));
	 		props.setLook(wSelectFolder);
			fdSelectFolder=new FormData();
			wSelectFolder.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.SelectFolderConnection.Tooltip"));
			fdSelectFolder.top  = new FormAttachment(wPOP3Settings, margin);
			fdSelectFolder.right= new FormAttachment(100, 0);
			wSelectFolder.setLayoutData(fdSelectFolder);
		    
			// TestIMAPFolder button
			wTestIMAPFolder=new Button(wIMAPSettings,SWT.PUSH);
			wTestIMAPFolder.setText(BaseMessages.getString(PKG, "JobGetPOP.TestIMAPFolderConnection.Label"));
	 		props.setLook(wTestIMAPFolder);
			fdTestIMAPFolder=new FormData();
			wTestIMAPFolder.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.TestIMAPFolderConnection.Tooltip"));
			fdTestIMAPFolder.top  = new FormAttachment(wPOP3Settings, margin);
			fdTestIMAPFolder.right= new FormAttachment(wSelectFolder, -margin);
			wTestIMAPFolder.setLayoutData(fdTestIMAPFolder);

			// IMAPFolder line
			wlIMAPFolder=new Label(wIMAPSettings, SWT.RIGHT);
			wlIMAPFolder.setText(BaseMessages.getString(PKG, "JobGetPOP.IMAPFolder.Label"));
			props.setLook(wlIMAPFolder);
			fdlIMAPFolder=new FormData();
			fdlIMAPFolder.left = new FormAttachment(0, 0);
			fdlIMAPFolder.top  = new FormAttachment(wPOP3Settings, margin);
			fdlIMAPFolder.right= new FormAttachment(middle, -margin);
			wlIMAPFolder.setLayoutData(fdlIMAPFolder);
			wIMAPFolder =new TextVar(jobMeta, wIMAPSettings, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wIMAPFolder);
			wIMAPFolder.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.IMAPFolder.Tooltip"));
			wIMAPFolder.addModifyListener(lsMod);
			fdIMAPFolder=new FormData();
			fdIMAPFolder.left = new FormAttachment(middle, 0);
			fdIMAPFolder.top  = new FormAttachment(wPOP3Settings, margin);
			fdIMAPFolder.right= new FormAttachment(wTestIMAPFolder, -margin);
			wIMAPFolder.setLayoutData(fdIMAPFolder);
			

			// Include subfolders?
			wlIncludeSubFolders=new Label(wIMAPSettings, SWT.RIGHT);
			wlIncludeSubFolders.setText(BaseMessages.getString(PKG, "JobGetPOP.IncludeSubFoldersMails.Label"));
			props.setLook(wlIncludeSubFolders);
			fdlIncludeSubFolders=new FormData();
			fdlIncludeSubFolders.left = new FormAttachment(0, 0);
			fdlIncludeSubFolders.top  = new FormAttachment(wIMAPFolder, margin);
			fdlIncludeSubFolders.right= new FormAttachment(middle, -margin);
			wlIncludeSubFolders.setLayoutData(fdlIncludeSubFolders);
			wIncludeSubFolders=new Button(wIMAPSettings, SWT.CHECK);
			props.setLook(wIncludeSubFolders);
			fdIncludeSubFolders=new FormData();
			wIncludeSubFolders.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.IncludeSubFoldersMails.Tooltip"));
			fdIncludeSubFolders.left = new FormAttachment(middle, 0);
			fdIncludeSubFolders.top  = new FormAttachment(wIMAPFolder, margin);
			fdIncludeSubFolders.right= new FormAttachment(100, 0);
			wIncludeSubFolders.setLayoutData(fdIncludeSubFolders);
			wIncludeSubFolders.addSelectionListener(lsSelection) ;


			
			// List of mails of retrieve
			wlIMAPListmails = new Label(wIMAPSettings, SWT.RIGHT);
			wlIMAPListmails.setText(BaseMessages.getString(PKG, "JobGetPOP.IMAPListmails.Label"));
			props.setLook(wlIMAPListmails);
			fdlIMAPListmails = new FormData();
			fdlIMAPListmails.left = new FormAttachment(0, 0);
			fdlIMAPListmails.right = new FormAttachment(middle, -margin);
			fdlIMAPListmails.top = new FormAttachment(wIncludeSubFolders, margin);
			wlIMAPListmails.setLayoutData(fdlIMAPListmails);
			wIMAPListmails = new CCombo(wIMAPSettings, SWT.SINGLE | SWT.READ_ONLY | SWT.BORDER);
			wIMAPListmails.setItems(MailConnectionMeta.valueIMAPListDesc);
			wIMAPListmails.select(0); // +1: starts at -1

			props.setLook(wIMAPListmails);
			fdIMAPListmails= new FormData();
			fdIMAPListmails.left = new FormAttachment(middle, 0);
			fdIMAPListmails.top = new FormAttachment(wIncludeSubFolders, margin);
			fdIMAPListmails.right = new FormAttachment(100, 0);
			wIMAPListmails.setLayoutData(fdIMAPListmails);

			wIMAPListmails.addSelectionListener(new SelectionAdapter()
			{
				public void widgetSelected(SelectionEvent e)
				{
					//ChooseIMAPListmails();
					
				}
			});
		    
			// Retrieve the first ... mails
			wlIMAPFirstmails = new Label(wIMAPSettings, SWT.RIGHT);
			wlIMAPFirstmails.setText(BaseMessages.getString(PKG, "JobGetPOP.IMAPFirstmails.Label"));
			props.setLook(wlIMAPFirstmails);
			fdlIMAPFirstmails = new FormData();
			fdlIMAPFirstmails.left = new FormAttachment(0, 0);
			fdlIMAPFirstmails.right = new FormAttachment(middle, -margin);
			fdlIMAPFirstmails.top = new FormAttachment(wIMAPListmails, margin);
			wlIMAPFirstmails.setLayoutData(fdlIMAPFirstmails);

			wIMAPFirstmails = new TextVar(jobMeta, wIMAPSettings, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wIMAPFirstmails);
			wIMAPFirstmails.addModifyListener(lsMod);
			fdIMAPFirstmails = new FormData();
			fdIMAPFirstmails.left = new FormAttachment(middle, 0);
			fdIMAPFirstmails.top = new FormAttachment(wIMAPListmails, margin);
			fdIMAPFirstmails.right = new FormAttachment(100, 0);
			wIMAPFirstmails.setLayoutData(fdIMAPFirstmails);
			
			// After get IMAP
			wlAfterGetIMAP = new Label(wIMAPSettings, SWT.RIGHT);
			wlAfterGetIMAP.setText(BaseMessages.getString(PKG, "JobGetPOP.AfterGetIMAP.Label"));
			props.setLook(wlAfterGetIMAP);
			fdlAfterGetIMAP = new FormData();
			fdlAfterGetIMAP.left = new FormAttachment(0, 0);
			fdlAfterGetIMAP.right = new FormAttachment(middle, -margin);
			fdlAfterGetIMAP.top = new FormAttachment(wIMAPFirstmails, 2*margin);
			wlAfterGetIMAP.setLayoutData(fdlAfterGetIMAP);
			wAfterGetIMAP = new CCombo(wIMAPSettings, SWT.SINGLE | SWT.READ_ONLY | SWT.BORDER);
			wAfterGetIMAP.setItems(MailConnectionMeta.afterGetIMAPDesc);
			wAfterGetIMAP.select(0); // +1: starts at -1

			props.setLook(wAfterGetIMAP);
			fdAfterGetIMAP= new FormData();
			fdAfterGetIMAP.left = new FormAttachment(middle, 0);
			fdAfterGetIMAP.top = new FormAttachment(wIMAPFirstmails, 2*margin);
			fdAfterGetIMAP.right = new FormAttachment(100, 0);
			wAfterGetIMAP.setLayoutData(fdAfterGetIMAP);

			wAfterGetIMAP.addSelectionListener(new SelectionAdapter()
			{
				public void widgetSelected(SelectionEvent e)
				{
					setAfterIMAPRetrived();
					jobEntry.setChanged();
				}
			});
			
			// MoveToFolder line
			wlMoveToFolder=new Label(wIMAPSettings, SWT.RIGHT);
			wlMoveToFolder.setText(BaseMessages.getString(PKG, "JobGetPOP.MoveToFolder.Label"));
			props.setLook(wlMoveToFolder);
			fdlMoveToFolder=new FormData();
			fdlMoveToFolder.left = new FormAttachment(0, 0);
			fdlMoveToFolder.top  = new FormAttachment(wAfterGetIMAP, margin);
			fdlMoveToFolder.right= new FormAttachment(middle, -margin);
			wlMoveToFolder.setLayoutData(fdlMoveToFolder);
			
			
		    
			// SelectMoveToFolder button
			wSelectMoveToFolder=new Button(wIMAPSettings,SWT.PUSH);
			wSelectMoveToFolder.setText(BaseMessages.getString(PKG, "JobGetPOP.SelectMoveToFolderConnection.Label"));
	 		props.setLook(wSelectMoveToFolder);
			fdSelectMoveToFolder=new FormData();
			wSelectMoveToFolder.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.SelectMoveToFolderConnection.Tooltip"));
			fdSelectMoveToFolder.top  = new FormAttachment(wAfterGetIMAP, margin);
			fdSelectMoveToFolder.right= new FormAttachment(100, 0);
			wSelectMoveToFolder.setLayoutData(fdSelectMoveToFolder);
		    
			// TestMoveToFolder button
			wTestMoveToFolder=new Button(wIMAPSettings,SWT.PUSH);
			wTestMoveToFolder.setText(BaseMessages.getString(PKG, "JobGetPOP.TestMoveToFolderConnection.Label"));
	 		props.setLook(wTestMoveToFolder);
			fdTestMoveToFolder=new FormData();
			wTestMoveToFolder.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.TestMoveToFolderConnection.Tooltip"));
			fdTestMoveToFolder.top  = new FormAttachment(wAfterGetIMAP, margin);
			fdTestMoveToFolder.right= new FormAttachment(wSelectMoveToFolder, -margin);
			wTestMoveToFolder.setLayoutData(fdTestMoveToFolder);
			
			wMoveToFolder =new TextVar(jobMeta, wIMAPSettings, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wMoveToFolder);
			wMoveToFolder.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.MoveToFolder.Tooltip"));
			wMoveToFolder.addModifyListener(lsMod);
			fdMoveToFolder=new FormData();
			fdMoveToFolder.left = new FormAttachment(middle, 0);
			fdMoveToFolder.top  = new FormAttachment(wAfterGetIMAP, margin);
			fdMoveToFolder.right= new FormAttachment(wTestMoveToFolder, -margin);
			wMoveToFolder.setLayoutData(fdMoveToFolder);
			
			// Create move to folder
			wlcreateMoveToFolder=new Label(wIMAPSettings, SWT.RIGHT);
			wlcreateMoveToFolder.setText(BaseMessages.getString(PKG, "JobGetPOP.createMoveToFolderMails.Label"));
			props.setLook(wlcreateMoveToFolder);
			fdlcreateMoveToFolder=new FormData();
			fdlcreateMoveToFolder.left = new FormAttachment(0, 0);
			fdlcreateMoveToFolder.top  = new FormAttachment(wMoveToFolder, margin);
			fdlcreateMoveToFolder.right= new FormAttachment(middle, -margin);
			wlcreateMoveToFolder.setLayoutData(fdlcreateMoveToFolder);
			wcreateMoveToFolder=new Button(wIMAPSettings, SWT.CHECK);
			props.setLook(wcreateMoveToFolder);
			fdcreateMoveToFolder=new FormData();
			wcreateMoveToFolder.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.createMoveToFolderMails.Tooltip"));
			fdcreateMoveToFolder.left = new FormAttachment(middle, 0);
			fdcreateMoveToFolder.top  = new FormAttachment(wMoveToFolder, margin);
			fdcreateMoveToFolder.right= new FormAttachment(100, 0);
			wcreateMoveToFolder.setLayoutData(fdcreateMoveToFolder);

		    
		    fdIMAPSettings= new FormData();
		    fdIMAPSettings.left = new FormAttachment(0, margin);
		    fdIMAPSettings.top = new FormAttachment(wPOP3Settings, 2*margin);
		    fdIMAPSettings.right = new FormAttachment(100, -margin);
		    wIMAPSettings.setLayoutData(fdIMAPSettings);
		    // ///////////////////////////////////////////////////////////
		    // / END OF IMAP SETTINGS GROUP
		    // ///////////////////////////////////////////////////////////

		    
			
			fdSettingsComp=new FormData();
			fdSettingsComp.left  = new FormAttachment(0, 0);
			fdSettingsComp.top   = new FormAttachment(wName, 0);
			fdSettingsComp.right = new FormAttachment(100, 0);
			fdSettingsComp.bottom= new FormAttachment(100, 0);
			wSettingsComp.setLayoutData(fdSettingsComp);
			
			wSettingsComp.layout();
			wSettingsTab.setControl(wSettingsComp);
	 		props.setLook(wSettingsComp);
	 		
			/////////////////////////////////////////////////////////////
			/// END OF Pop TAB
			/////////////////////////////////////////////////////////////
			
	 		//////////////////////////
			// START OF SEARCH TAB   ///
			//////////////////////////

			wSearchTab=new CTabItem(wTabFolder, SWT.NONE);
			wSearchTab.setText(BaseMessages.getString(PKG, "JobGetPOP.Tab.Search.Label"));
			wSearchComp = new Composite(wTabFolder, SWT.NONE);
	 		props.setLook(wSearchComp);
			FormLayout searchLayout = new FormLayout();
			searchLayout.marginWidth  = 3;
			searchLayout.marginHeight = 3;
			wSearchComp.setLayout(searchLayout);
			

		     // ////////////////////////
		     // START OF HEADER ROUP///
		     // /
		    wHeader= new Group(wSearchComp, SWT.SHADOW_NONE);
		    props.setLook(wHeader);
		    wHeader.setText(BaseMessages.getString(PKG, "JobGetPOP.Header.Group.Label"));

		    FormLayout HeadergroupLayout = new FormLayout();
		    HeadergroupLayout.marginWidth = 10;
		    HeadergroupLayout.marginHeight = 10;
		    wHeader.setLayout(HeadergroupLayout);
			
			wNegateSender=new Button(wHeader, SWT.CHECK);
			props.setLook(wNegateSender);
			fdNegateSender=new FormData();
			wNegateSender.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.NegateSender.Tooltip"));
			fdNegateSender.top  = new FormAttachment(0, margin);
			fdNegateSender.right= new FormAttachment(100, -margin);
			wNegateSender.setLayoutData(fdNegateSender);

			// From line
			wlSender=new Label(wHeader, SWT.RIGHT);
			wlSender.setText(BaseMessages.getString(PKG, "JobGetPOP.wSender.Label"));
			props.setLook(wlSender);
			fdlSender=new FormData();
			fdlSender.left = new FormAttachment(0, 0);
			fdlSender.top  = new FormAttachment(0, margin);
			fdlSender.right= new FormAttachment(middle, -margin);
			wlSender.setLayoutData(fdlSender);
			wSender=new TextVar(jobMeta, wHeader, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wSender);
			wSender.addModifyListener(lsMod);
			fdSender=new FormData();
			fdSender.left = new FormAttachment(middle, 0);
			fdSender.top  = new FormAttachment(0, margin);
			fdSender.right= new FormAttachment(wNegateSender, -margin);
			wSender.setLayoutData(fdSender);
			
			wNegateReceipient=new Button(wHeader, SWT.CHECK);
			props.setLook(wNegateReceipient);
			fdNegateReceipient=new FormData();
			wNegateReceipient.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.NegateReceipient.Tooltip"));
			fdNegateReceipient.top  = new FormAttachment(wSender, margin);
			fdNegateReceipient.right= new FormAttachment(100, -margin);
			wNegateReceipient.setLayoutData(fdNegateReceipient);
			
			// Receipient line
			wlReceipient=new Label(wHeader, SWT.RIGHT);
			wlReceipient.setText(BaseMessages.getString(PKG, "JobGetPOP.Receipient.Label"));
			props.setLook(wlReceipient);
			fdlReceipient=new FormData();
			fdlReceipient.left = new FormAttachment(0, 0);
			fdlReceipient.top  = new FormAttachment(wSender, margin);
			fdlReceipient.right= new FormAttachment(middle, -margin);
			wlReceipient.setLayoutData(fdlReceipient);
			wReceipient=new TextVar(jobMeta, wHeader, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wReceipient);
			wReceipient.addModifyListener(lsMod);
			fdReceipient=new FormData();
			fdReceipient.left = new FormAttachment(middle, 0);
			fdReceipient.top  = new FormAttachment(wSender, margin);
			fdReceipient.right= new FormAttachment(wNegateReceipient, -margin);
			wReceipient.setLayoutData(fdReceipient);
			
			wNegateSubject=new Button(wHeader, SWT.CHECK);
			props.setLook(wNegateSubject);
			fdNegateSubject=new FormData();
			wNegateSubject.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.NegateSubject.Tooltip"));
			fdNegateSubject.top  = new FormAttachment(wReceipient, margin);
			fdNegateSubject.right= new FormAttachment(100, -margin);
			wNegateSubject.setLayoutData(fdNegateSubject);
			
			
			// Subject line
			wlSubject=new Label(wHeader, SWT.RIGHT);
			wlSubject.setText(BaseMessages.getString(PKG, "JobGetPOP.Subject.Label"));
			props.setLook(wlSubject);
			fdlSubject=new FormData();
			fdlSubject.left = new FormAttachment(0, 0);
			fdlSubject.top  = new FormAttachment(wReceipient, margin);
			fdlSubject.right= new FormAttachment(middle, -margin);
			wlSubject.setLayoutData(fdlSubject);
			wSubject=new TextVar(jobMeta, wHeader, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wSubject);
			wSubject.addModifyListener(lsMod);
			fdSubject=new FormData();
			fdSubject.left = new FormAttachment(middle, 0);
			fdSubject.top  = new FormAttachment(wReceipient, margin);
			fdSubject.right= new FormAttachment(wNegateSubject, -margin);
			wSubject.setLayoutData(fdSubject);
			
		    fdHeader= new FormData();
		    fdHeader.left = new FormAttachment(0, margin);
		    fdHeader.top = new FormAttachment(wReceipient, 2*margin);
		    fdHeader.right = new FormAttachment(100, -margin);
		    wHeader.setLayoutData(fdHeader);
		    // ///////////////////////////////////////////////////////////
		    // / END OF HEADER GROUP
		    // ///////////////////////////////////////////////////////////
			
		    
		     // ////////////////////////
		     // START OF CONTENT GROUP///
		     // /
		    wContent= new Group(wSearchComp, SWT.SHADOW_NONE);
		    props.setLook(wContent);
		    wContent.setText(BaseMessages.getString(PKG, "JobGetPOP.Content.Group.Label"));

		    FormLayout ContentgroupLayout = new FormLayout();
		    ContentgroupLayout .marginWidth = 10;
		    ContentgroupLayout .marginHeight = 10;
		    wContent.setLayout(ContentgroupLayout );


			wNegateBody=new Button(wContent, SWT.CHECK);
			props.setLook(wNegateBody);
			fdNegateBody=new FormData();
			wNegateBody.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.NegateBody.Tooltip"));
			fdNegateBody.top  = new FormAttachment(wHeader, margin);
			fdNegateBody.right= new FormAttachment(100, -margin);
			wNegateBody.setLayoutData(fdNegateBody);
			
			
			// Body line
			wlBody=new Label(wContent, SWT.RIGHT);
			wlBody.setText(BaseMessages.getString(PKG, "JobGetPOP.Body.Label"));
			props.setLook(wlBody);
			fdlBody=new FormData();
			fdlBody.left = new FormAttachment(0, 0);
			fdlBody.top  = new FormAttachment(wHeader, margin);
			fdlBody.right= new FormAttachment(middle, -margin);
			wlBody.setLayoutData(fdlBody);
			wBody=new TextVar(jobMeta, wContent, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			props.setLook(wBody);
			wBody.addModifyListener(lsMod);
			fdBody=new FormData();
			fdBody.left = new FormAttachment(middle, 0);
			fdBody.top  = new FormAttachment(wHeader, margin);
			fdBody.right= new FormAttachment(wNegateBody, -margin);
			wBody.setLayoutData(fdBody);

		    fdContent= new FormData();
		    fdContent.left = new FormAttachment(0, margin);
		    fdContent.top = new FormAttachment(wHeader, margin);
		    fdContent.right = new FormAttachment(100, -margin);
		    wContent.setLayoutData(fdContent);
		    // ///////////////////////////////////////////////////////////
		    // / END OF CONTENT GROUP
		    // ///////////////////////////////////////////////////////////
			
		    
		    
		     // ////////////////////////
		     // START OF RECEIVED DATE ROUP///
		     // /
		    wReceivedDate= new Group(wSearchComp, SWT.SHADOW_NONE);
		    props.setLook(wReceivedDate);
		    wReceivedDate.setText(BaseMessages.getString(PKG, "JobGetPOP.ReceivedDate.Group.Label"));

		    FormLayout ReceivedDategroupLayout = new FormLayout();
		    ReceivedDategroupLayout.marginWidth = 10;
		    ReceivedDategroupLayout.marginHeight = 10;
		    wReceivedDate.setLayout(ReceivedDategroupLayout);

			wNegateReceivedDate=new Button(wReceivedDate, SWT.CHECK);
			props.setLook(wNegateReceivedDate);
			fdNegateReceivedDate=new FormData();
			wNegateReceivedDate.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.NegateReceivedDate.Tooltip"));
			fdNegateReceivedDate.top  = new FormAttachment(wContent, margin);
			fdNegateReceivedDate.right= new FormAttachment(100, -margin);
			wNegateReceivedDate.setLayoutData(fdNegateReceivedDate);
			
			
		    //Received Date Condition
		  	wlConditionOnReceivedDate= new Label(wReceivedDate, SWT.RIGHT);
		  	wlConditionOnReceivedDate.setText(BaseMessages.getString(PKG, "JobGetPOP.ConditionOnReceivedDate.Label"));
		  	props.setLook(wlConditionOnReceivedDate);
		  	fdlConditionOnReceivedDate= new FormData();
		  	fdlConditionOnReceivedDate.left = new FormAttachment(0, 0);
		  	fdlConditionOnReceivedDate.right = new FormAttachment(middle, -margin);
		  	fdlConditionOnReceivedDate.top = new FormAttachment(wContent, margin);
		  	wlConditionOnReceivedDate.setLayoutData(fdlConditionOnReceivedDate);
		  	
		  	wConditionOnReceivedDate= new CCombo(wReceivedDate, SWT.SINGLE | SWT.READ_ONLY | SWT.BORDER);
		  	wConditionOnReceivedDate.setItems(MailConnectionMeta.conditionDateDesc);
		  	wConditionOnReceivedDate.select(0); // +1: starts at -1
		  	
			props.setLook(wConditionOnReceivedDate);
			fdConditionOnReceivedDate= new FormData();
			fdConditionOnReceivedDate.left = new FormAttachment(middle, 0);
			fdConditionOnReceivedDate.top = new FormAttachment(wContent, margin);
			fdConditionOnReceivedDate.right = new FormAttachment(wNegateReceivedDate, -margin);
			wConditionOnReceivedDate.setLayoutData(fdConditionOnReceivedDate);
			wConditionOnReceivedDate.addSelectionListener(new SelectionAdapter()
			{
				public void widgetSelected(SelectionEvent e)
				{
					conditionReceivedDate();
					jobEntry.setChanged();
				}
			});
		    
		    
		    open = new Button (wReceivedDate, SWT.PUSH);
			open.setImage(GUIResource.getInstance().getImageCalendar());
			open.setToolTipText (BaseMessages.getString(PKG, "JobGetPOP.OpenCalendar"));
		    FormData fdlButton=new FormData();
		    fdlButton.top  = new FormAttachment(wConditionOnReceivedDate, margin);
		    fdlButton.right= new FormAttachment(100, 0);
		    open.setLayoutData(fdlButton);
		    open.addSelectionListener (new SelectionAdapter () {
				public void widgetSelected (SelectionEvent e) {
					final Shell dialog = new Shell (shell, SWT.DIALOG_TRIM );
					dialog.setText(BaseMessages.getString(PKG, "JobGetPOP.SelectDate"));
					dialog.setImage(GUIResource.getInstance().getImageSpoon());
					dialog.setLayout (new GridLayout (3, false));

					final DateTime calendar = new DateTime (dialog, SWT.CALENDAR);
				    final DateTime time = new DateTime (dialog, SWT.TIME | SWT.TIME);
					new Label (dialog, SWT.NONE);
					new Label (dialog, SWT.NONE);

					Button ok = new Button (dialog, SWT.PUSH);
					ok.setText(BaseMessages.getString(PKG, "System.Button.OK"));
					ok.setLayoutData(new GridData (SWT.FILL, SWT.CENTER, false, false));
					ok.addSelectionListener (new SelectionAdapter () {
						public void widgetSelected (SelectionEvent e) {
							wReadFrom.setText(calendar.getYear()+"-"+
									((calendar.getMonth () + 1)<10 ? "0"+(calendar.getMonth () + 1) : (calendar.getMonth () + 1)) 
											+"-"+(calendar.getDay ()<10 ? "0"+calendar.getDay () : calendar.getDay ())
											+" "+(time.getHours()<10 ? "0"+time.getHours() : time.getHours())
											+":"+(time.getMinutes()<10 ? "0"+time.getMinutes() : time.getMinutes())
											+":"+(time.getMinutes()<10 ? "0"+time.getMinutes() : time.getMinutes())					
							); 
					          
							dialog.close ();
						}
					});
					dialog.setDefaultButton (ok);
					dialog.pack ();
					dialog.open ();
				}
			});
			
			wlReadFrom=new Label(wReceivedDate, SWT.RIGHT);
			wlReadFrom.setText(BaseMessages.getString(PKG, "JobGetPOP.ReadFrom.Label"));
	 		props.setLook(wlReadFrom);
			fdlReadFrom=new FormData();
			fdlReadFrom.left = new FormAttachment(0, 0);
			fdlReadFrom.top  = new FormAttachment(wConditionOnReceivedDate, margin);
			fdlReadFrom.right= new FormAttachment(middle, -margin);
			wlReadFrom.setLayoutData(fdlReadFrom);
			wReadFrom=new TextVar(jobMeta, wReceivedDate, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			wReadFrom.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.ReadFrom.Tooltip"));
	 		props.setLook(wReadFrom);
			wReadFrom.addModifyListener(lsMod);
			fdReadFrom=new FormData();
			fdReadFrom.left = new FormAttachment(middle, 0);
			fdReadFrom.top  = new FormAttachment(wConditionOnReceivedDate, margin);
			fdReadFrom.right= new FormAttachment(open, -margin);
			wReadFrom.setLayoutData(fdReadFrom);

			
			opento = new Button (wReceivedDate, SWT.PUSH);
			opento.setImage(GUIResource.getInstance().getImageCalendar());
			opento.setToolTipText (BaseMessages.getString(PKG, "JobGetPOP.OpenCalendar"));
		    FormData fdlButtonto=new FormData();
		    fdlButtonto.top  = new FormAttachment(wReadFrom, 2*margin);
		    fdlButtonto.right= new FormAttachment(100, 0);
		    opento.setLayoutData(fdlButtonto);
		    opento.addSelectionListener (new SelectionAdapter () {
				public void widgetSelected (SelectionEvent e) {
					final Shell dialogto = new Shell (shell, SWT.DIALOG_TRIM );
					dialogto.setText(BaseMessages.getString(PKG, "JobGetPOP.SelectDate"));
					dialogto.setImage(GUIResource.getInstance().getImageSpoon());
					dialogto.setLayout (new GridLayout (3, false));

					final DateTime calendarto = new DateTime (dialogto, SWT.CALENDAR | SWT.BORDER);
				    final DateTime timeto = new DateTime (dialogto, SWT.TIME | SWT.TIME);
					new Label (dialogto, SWT.NONE);
					new Label (dialogto, SWT.NONE);
					Button okto = new Button (dialogto, SWT.PUSH);
					okto.setText(BaseMessages.getString(PKG, "System.Button.OK"));
					okto.setLayoutData(new GridData (SWT.FILL, SWT.CENTER, false, false));
					okto.addSelectionListener (new SelectionAdapter () {
						public void widgetSelected (SelectionEvent e) {
							wReadTo.setText(calendarto.getYear()+"-"+
									((calendarto.getMonth() + 1)<10 ? "0"+(calendarto.getMonth () + 1) : (calendarto.getMonth () + 1)) 
									+"-"+(calendarto.getDay ()<10 ? "0"+calendarto.getDay () : calendarto.getDay())
									+" "+(timeto.getHours()<10 ? "0"+timeto.getHours() : timeto.getHours())
									+":"+(timeto.getMinutes()<10 ? "0"+timeto.getMinutes() : timeto.getMinutes())
									+":"+(timeto.getSeconds()<10 ? "0"+timeto.getSeconds() : timeto.getSeconds())
							); 
							dialogto.close ();
						}
					});
					dialogto.setDefaultButton (okto);
					dialogto.pack ();
					dialogto.open ();
				}
			});
			
			wlReadTo=new Label(wReceivedDate, SWT.RIGHT);
			wlReadTo.setText(BaseMessages.getString(PKG, "JobGetPOP.ReadTo.Label"));
	 		props.setLook(wlReadTo);
			fdlReadTo=new FormData();
			fdlReadTo.left = new FormAttachment(0, 0);
			fdlReadTo.top  = new FormAttachment(wReadFrom, 2*margin);
			fdlReadTo.right= new FormAttachment(middle, -margin);
			wlReadTo.setLayoutData(fdlReadTo);
			wReadTo=new TextVar(jobMeta, wReceivedDate, SWT.SINGLE | SWT.LEFT | SWT.BORDER);
			wReadTo.setToolTipText(BaseMessages.getString(PKG, "JobGetPOP.ReadTo.Tooltip"));
	 		props.setLook(wReadTo);
			wReadTo.addModifyListener(lsMod);
			fdReadTo=new FormData();
			fdReadTo.left = new FormAttachment(middle, 0);
			fdReadTo.top  = new FormAttachment(wReadFrom, 2*margin);
			fdReadTo.right= new FormAttachment(opento, -margin);
			wReadTo.setLayoutData(fdReadTo);




		    fdReceivedDate= new FormData();
		    fdReceivedDate.left = new FormAttachment(0, margin);
		    fdReceivedDate.top = new FormAttachment(wContent, margin);
		    fdReceivedDate.right = new FormAttachment(100, -margin);
		    wReceivedDate.setLayoutData(fdReceivedDate);
		    // ///////////////////////////////////////////////////////////
		    // / END OF RECEIVED DATE GROUP
		    // ///////////////////////////////////////////////////////////
			
			fdSearchComp=new FormData();
			fdSearchComp.left  = new FormAttachment(0, 0);
			fdSearchComp.top   = new FormAttachment(wName, 0);
			fdSearchComp.right = new FormAttachment(100, 0);
			fdSearchComp.bottom= new FormAttachment(100, 0);
			wSearchComp.setLayoutData(fdSearchComp);
			
			wSearchComp.layout();
			wSearchTab.setControl(wSearchComp);
	 		props.setLook(wSearchComp);
	 		
			//////////////////////////////////
			/// END OF SEARCH TAB
			//////////////////////////////////
			

			fdTabFolder = new FormData();
			fdTabFolder.left  = new FormAttachment(0, 0);
			fdTabFolder.top   = new FormAttachment(wName, margin);
			fdTabFolder.right = new FormAttachment(100, 0);
			fdTabFolder.bottom= new FormAttachment(100, -50);
			wTabFolder.setLayoutData(fdTabFolder);
			
			
	        wOK = new Button(shell, SWT.PUSH);
	        wOK.setText(BaseMessages.getString(PKG, "System.Button.OK"));
	        wCancel = new Button(shell, SWT.PUSH);
	        wCancel.setText(BaseMessages.getString(PKG, "System.Button.Cancel"));

	        BaseStepDialog.positionBottomButtons(shell, new Button[] { wOK, wCancel }, margin, wTabFolder);

	        // Add listeners
	        lsCancel = new Listener()
	        {
	            public void handleEvent(Event e)
	            {
	                cancel();
	            }
	        };
	        lsOK = new Listener()
	        {
	            public void handleEvent(Event e)
	            {
	                ok();
	            }
	        };

	        wCancel.addListener(SWT.Selection, lsCancel);
	        wOK.addListener(SWT.Selection, lsOK);

	        lsDef = new SelectionAdapter()
	        {
	            public void widgetDefaultSelected(SelectionEvent e)
	            {
	                ok();
	            }
	        };
	        lsTest     = new Listener() { public void handleEvent(Event e) { test(); } };
	        wTest.addListener    (SWT.Selection, lsTest    );
	        
	        lsTestIMAPFolder     = new Listener() { public void handleEvent(Event e) { checkFolder(jobMeta.environmentSubstitute(wIMAPFolder.getText())); } };
	        wTestIMAPFolder.addListener    (SWT.Selection, lsTestIMAPFolder    );
	        
	        lsTestMoveToFolder     = new Listener() { public void handleEvent(Event e) { checkFolder(jobMeta.environmentSubstitute(wMoveToFolder.getText())); } };
	        wTestMoveToFolder.addListener    (SWT.Selection, lsTestMoveToFolder    );
	        
	        lsSelectFolder     = new Listener() { public void handleEvent(Event e) { selectFolder(wIMAPFolder); } };
	        wSelectFolder.addListener    (SWT.Selection, lsSelectFolder    );
	        
	        lsSelectMoveToFolder     = new Listener() { public void handleEvent(Event e) { selectFolder(wMoveToFolder); } };
	        wSelectMoveToFolder.addListener    (SWT.Selection, lsSelectMoveToFolder    );
	        
	        wName.addSelectionListener(lsDef);
	        wServerName.addSelectionListener(lsDef);

	        // Detect X or ALT-F4 or something that kills this window...
	        shell.addShellListener(new ShellAdapter()
	        {
	            public void shellClosed(ShellEvent e)
	            {
	                cancel();
	            }
	        });

	        getData();
	        setUserProxy();
			chooseListMails();
			activeAttachmentFolder();
			refreshProtocal(false);
			conditionReceivedDate();
			wTabFolder.setSelection(0);
	        BaseStepDialog.setSize(shell);

	        shell.open();
	        props.setDialogSize(shell, "JobEntryGetPOPDialogSize");
	        while (!shell.isDisposed())
	        {
	            if (!display.readAndDispatch())
	                display.sleep();
	        }
	        return jobEntry;
	    }
	    private void setUserProxy()
	    {
	    	wlProxyUsername.setEnabled(wUseProxy.getSelection());
	    	wProxyUsername.setEnabled(wUseProxy.getSelection());
	    }
	    
	    private boolean connect()
	    {
	    	String errordescription=null;
	    	boolean retval=false;
	    	if(mailConn!=null && mailConn.isConnected()) retval=mailConn.isConnected();
	    	
	    	if(!retval) { 
		    	String realserver=jobMeta.environmentSubstitute(wServerName.getText());
		    	String realuser=jobMeta.environmentSubstitute(wUserName.getText());
		    	String realpass=jobMeta.environmentSubstitute(wPassword.getText());
		    	int realport=Const.toInt(jobMeta.environmentSubstitute(wPort.getText()),-1);
		    	String realproxyuser=jobMeta.environmentSubstitute(wProxyUsername.getText());
		    	try{
		    		mailConn=new MailConnection(LogChannel.UI, wProtocol.getText().equals(MailConnectionMeta.PROTOCOL_STRING_POP3)?MailConnectionMeta.PROTOCOL_POP3:MailConnectionMeta.PROTOCOL_IMAP
		    				,realserver,realport, realuser, realpass, wUseSSL.getSelection(), 
		    				wUseProxy.getSelection(),realproxyuser);
		    		mailConn.connect();
		    		
		    		retval=true;
		    	}catch(Exception e) {
		    		errordescription=e.getMessage();
		    	}
	    	}
	        
	        if(!retval) {
		    	MessageBox mb = new MessageBox(shell, SWT.OK | SWT.ICON_ERROR );
				mb.setMessage(BaseMessages.getString(PKG, "JobGetPOP.Connected.NOK.ConnectionBad",wServerName.getText()) 
						+Const.CR+Const.NVL(errordescription,""));
				mb.setText(BaseMessages.getString(PKG, "JobGetPOP.Connected.Title.Bad"));
				mb.open(); 
	        }
	        
	    	return (mailConn.isConnected());

	    }
	    private void test() {
	    	if(connect()) {
				MessageBox mb = new MessageBox(shell, SWT.OK | SWT.ICON_INFORMATION );
				mb.setMessage(BaseMessages.getString(PKG, "JobGetPOP.Connected.OK",wServerName.getText()) +Const.CR);
				mb.setText(BaseMessages.getString(PKG, "JobGetPOP.Connected.Title.Ok"));
				mb.open();
			}
	    }
	    private void selectFolder(TextVar input)
	    {
	    	if(connect()) {
	    		try {
	    			Folder folder= mailConn.getStore().getDefaultFolder();
	    			SelectFolderDialog s= new SelectFolderDialog(shell, SWT.NONE, folder);
	    			String foldername= s.open();
	    			if(foldername!=null)
	    				input.setText(foldername);
	    		}catch(Exception e)
	    		{
	    			
	    		}
	    	}
	    }
	    private void checkFolder(String foldername) {
	    	if(!Const.isEmpty(foldername)) {
		    	if(connect()) {
		    		// check folder
		    		if(mailConn.folderExists(foldername)) {
						MessageBox mb = new MessageBox(shell, SWT.OK | SWT.ICON_INFORMATION );
						mb.setMessage(BaseMessages.getString(PKG, "JobGetPOP.IMAPFolderExists.OK",foldername) +Const.CR);
						mb.setText(BaseMessages.getString(PKG, "JobGetPOP.IMAPFolderExists.Title.Ok"));
						mb.open();
		    		} else {
		    	    	MessageBox mb = new MessageBox(shell, SWT.OK | SWT.ICON_ERROR );
		    			mb.setMessage(BaseMessages.getString(PKG, "JobGetPOP.Connected.NOK.IMAPFolderExists",foldername)+Const.CR);
		    			mb.setText(BaseMessages.getString(PKG, "JobGetPOP.IMAPFolderExists.Title.Bad"));
		    			mb.open(); 
		    		}
				}
	    	}
	    }
	    private void closeMailConnection() {
	    	try{
	    		if(mailConn!=null){
	    			mailConn.disconnect();
	    			mailConn=null;
	    		}
			}catch(Exception e){};
	    }
	    private void conditionReceivedDate()
	    {
	    	boolean activeReceivedDate=!(MailConnectionMeta.getConditionDateByDesc(wConditionOnReceivedDate.getText())==MailConnectionMeta.CONDITION_DATE_IGNORE);
	    	boolean useBetween=(MailConnectionMeta.getConditionDateByDesc(wConditionOnReceivedDate.getText())==MailConnectionMeta.CONDITION_DATE_BETWEEN);
			wlReadFrom.setVisible(activeReceivedDate);
			wReadFrom.setVisible(activeReceivedDate);
			open.setVisible(activeReceivedDate);
	    	wlReadTo.setVisible(activeReceivedDate && useBetween);
			wReadTo.setVisible(activeReceivedDate && useBetween);
			opento.setVisible(activeReceivedDate && useBetween);
	    }
	    private void activeAttachmentFolder()
	    {
	    	boolean getmessages=MailConnectionMeta.getActionTypeByDesc(wActionType.getText())==MailConnectionMeta.ACTION_TYPE_GET;
	    	wlDifferentFolderForAttachment.setEnabled(getmessages && wGetAttachment.getSelection());
	    	wDifferentFolderForAttachment.setEnabled(getmessages && wGetAttachment.getSelection());
	    	boolean activeattachmentfolder=(wGetAttachment.getSelection()&&wDifferentFolderForAttachment.getSelection());
	    	wlAttachmentFolder.setEnabled(getmessages && activeattachmentfolder);
	    	wAttachmentFolder.setEnabled(getmessages && activeattachmentfolder);
	    	wbAttachmentFolder.setEnabled(getmessages && activeattachmentfolder);
	    	if(!wGetAttachment.getSelection() && !wGetMessage.getSelection())
	    		wGetMessage.setSelection(true);
	    }
	    private void refreshPort(boolean refreshport)
	    {
	    	if(refreshport)
	    	{
	    		if(wProtocol.getText().equals(MailConnectionMeta.PROTOCOL_STRING_POP3))
	    		{
		    		if(wUseSSL.getSelection())
		    		{
		    			if(Const.isEmpty(wPort.getText()) || wPort.getText().equals(""+MailConnectionMeta.DEFAULT_SSL_IMAP_PORT))
		    				wPort.setText(""+MailConnectionMeta.DEFAULT_SSL_POP3_PORT);
		    		}
		    		else	
		    		{
		    			if(Const.isEmpty(wPort.getText()) || wPort.getText().equals(MailConnectionMeta.DEFAULT_IMAP_PORT))
		    				wPort.setText(""+MailConnectionMeta.DEFAULT_POP3_PORT);
		    		}
	    		}else
	    		{
		    		if(wUseSSL.getSelection())
		    		{
		    			if(Const.isEmpty(wPort.getText()) || wPort.getText().equals(""+MailConnectionMeta.DEFAULT_SSL_POP3_PORT))
		    				wPort.setText(""+MailConnectionMeta.DEFAULT_SSL_IMAP_PORT);
		    		}
		    		else	
		    		{
		    			if(Const.isEmpty(wPort.getText()) || wPort.getText().equals(MailConnectionMeta.DEFAULT_POP3_PORT))
		    			wPort.setText(""+MailConnectionMeta.DEFAULT_IMAP_PORT);	
		    		}
	    		}

	    	}
	    }
	    private void refreshProtocal(boolean refreshport)
	    {
	    	checkUnavailableMode();
	    	boolean activePOP3=wProtocol.getText().equals(MailConnectionMeta.PROTOCOL_STRING_POP3);
	    	wlPOP3Message.setEnabled(activePOP3);
	    	wlListmails.setEnabled(activePOP3);
	    	wListmails.setEnabled(activePOP3);
	    	wlFirstmails.setEnabled(activePOP3);
	    	wlDelete.setEnabled(activePOP3);
	    	wDelete.setEnabled(activePOP3);
	    	
	    	wlIMAPFirstmails.setEnabled(!activePOP3);
	    	wIMAPFirstmails.setEnabled(!activePOP3);
	    	wlIMAPFolder.setEnabled(!activePOP3);
	    	wIMAPFolder.setEnabled(!activePOP3);
	    	wlIncludeSubFolders.setEnabled(!activePOP3);
	    	wIncludeSubFolders.setEnabled(!activePOP3);
	    	wlIMAPListmails.setEnabled(!activePOP3);
	    	wIMAPListmails.setEnabled(!activePOP3);
	    	wTestIMAPFolder.setEnabled(!activePOP3);
	    	wSelectFolder.setEnabled(!activePOP3);
	    	wlAfterGetIMAP.setEnabled(!activePOP3);
	    	wAfterGetIMAP.setEnabled(!activePOP3);
	    	chooseListMails();
	    	refreshPort(refreshport);
	    	setActionType();
	    }
	    private void checkUnavailableMode(){
	    	if(wProtocol.getText().equals(MailConnectionMeta.PROTOCOL_STRING_POP3) && 
	    			MailConnectionMeta.getActionTypeByDesc(wActionType.getText())==MailConnectionMeta.ACTION_TYPE_MOVE) {
		    	MessageBox mb = new MessageBox(shell, SWT.OK | SWT.ICON_ERROR );
				mb.setMessage("This action is not available for POP3!"+Const.CR+
						"Only one Folder (INBOX) is available in POP3."+Const.CR+
						"If you want to move messages to another folder,"+Const.CR+
						"please use IMAP protocol.");
				mb.setText("ERROR");
				mb.open(); 
				wActionType.setText(MailConnectionMeta.getActionTypeDesc(MailConnectionMeta.ACTION_TYPE_GET));
	    	}	
	    }
	    private void setActionType()
	    {
	    	checkUnavailableMode();
	    	if(MailConnectionMeta.getActionTypeByDesc(wActionType.getText())!=MailConnectionMeta.ACTION_TYPE_GET)
	    		wAfterGetIMAP.setText(MailConnectionMeta.getAfterGetIMAPDesc(MailConnectionMeta.AFTER_GET_IMAP_NOTHING));
	    	
	    	boolean getmessages=MailConnectionMeta.getActionTypeByDesc(wActionType.getText())==MailConnectionMeta.ACTION_TYPE_GET;
	    	

	    	wlOutputDirectory.setEnabled(getmessages);
	    	wOutputDirectory.setEnabled(getmessages);
	    	wbDirectory.setEnabled(getmessages);
	    	wlcreateLocalFolder.setEnabled(getmessages);
	      	wcreateLocalFolder.setEnabled(getmessages);
	      	wFilenamePattern.setEnabled(getmessages);
	    	wlFilenamePattern.setEnabled(getmessages);
	    	wlAttachmentWildcard.setEnabled(getmessages);
	    	wAttachmentWildcard.setEnabled(getmessages);
	    	wlDifferentFolderForAttachment.setEnabled(getmessages);
	    	wDifferentFolderForAttachment.setEnabled(getmessages);
	    	wlGetAttachment.setEnabled(getmessages);
	    	wGetAttachment.setEnabled(getmessages);
	    	wlGetMessage.setEnabled(getmessages);
	    	wGetMessage.setEnabled(getmessages);
	    	
	    	
	    	wlAfterGetIMAP.setEnabled(getmessages && wProtocol.getText().equals(MailConnectionMeta.PROTOCOL_STRING_IMAP));
	    	wAfterGetIMAP.setEnabled(getmessages && wProtocol.getText().equals(MailConnectionMeta.PROTOCOL_STRING_IMAP));
	    	
	    	setAfterIMAPRetrived();
	    }
	    private void setAfterIMAPRetrived()
	    {
	    	boolean activeMoveToFolfer=(((wProtocol.getText().equals(MailConnectionMeta.PROTOCOL_STRING_IMAP)) && (MailConnectionMeta.getActionTypeByDesc(wActionType.getText())==MailConnectionMeta.ACTION_TYPE_MOVE))
	    		|| (MailConnectionMeta.getAfterGetIMAPByDesc(wAfterGetIMAP.getText())==MailConnectionMeta.AFTER_GET_IMAP_MOVE));
	    	wlMoveToFolder.setEnabled(activeMoveToFolfer);
	    	wMoveToFolder.setEnabled(activeMoveToFolfer);
	    	wTestMoveToFolder.setEnabled(activeMoveToFolfer);
	    	wSelectMoveToFolder.setEnabled(activeMoveToFolfer);
	    	wlcreateMoveToFolder.setEnabled(activeMoveToFolfer);
	    	wcreateMoveToFolder.setEnabled(activeMoveToFolfer);
	    }
		public void checkPasswordVisible()
		{
			String password = wPassword.getText();
			java.util.List<String> list = new ArrayList<String>();
			StringUtil.getUsedVariables(password, list, true);
			if (list.size() == 0){
				wPassword.setEchoChar('*');
			}else{
				wPassword.setEchoChar('\0'); // Show it all...
			}
		}
		public void chooseListMails()
		{
			boolean ok=(wProtocol.getText().equals(MailConnectionMeta.PROTOCOL_STRING_POP3) && wListmails.getSelectionIndex()==2);
			wlFirstmails.setEnabled(ok);
			wFirstmails.setEnabled(ok);
		}

	    public void dispose()
	    {
	    	closeMailConnection();
	        WindowProperty winprop = new WindowProperty(shell);
	        props.setScreen(winprop);
	        shell.dispose();
	    }

	    /**
	     * Copy information from the meta-data input to the dialog fields.
	     */
	    public void getData()
	    {
	        if (jobEntry.getName() != null)
	            wName.setText(jobEntry.getName());
	        wName.selectAll();
	        if (jobEntry.getServerName() != null)
	            wServerName.setText(jobEntry.getServerName());
			if (jobEntry.getUserName() != null)
				wUserName.setText(jobEntry.getUserName());
			if (jobEntry.getPassword() != null)
				wPassword.setText(jobEntry.getPassword());

			wUseSSL.setSelection(jobEntry.isUseSSL());
			wGetMessage.setSelection(jobEntry.isSaveMessage());
			wGetAttachment.setSelection(jobEntry.isSaveAttachment());
			wDifferentFolderForAttachment.setSelection(jobEntry.isDifferentFolderForAttachment());
			if (jobEntry.getAttachmentFolder() != null)
				wAttachmentFolder.setText(jobEntry.getAttachmentFolder());
			
			if (jobEntry.getPort() !=null)
			{
				wPort.setText(jobEntry.getPort());
			}
			
			if (jobEntry.getOutputDirectory() != null)
				wOutputDirectory.setText(jobEntry.getOutputDirectory());
			if (jobEntry.getFilenamePattern() != null)
				wFilenamePattern.setText(jobEntry.getFilenamePattern());
			if (jobEntry.getAttachmentWildcard() != null)
				wAttachmentWildcard.setText(jobEntry.getAttachmentWildcard());
			if (jobEntry.getRetrievemails()>=0) 
			{
				wListmails.select(jobEntry.getRetrievemails() );
			}
			else
			{
				wListmails.select(0); // Retrieve All Mails
			}

			if (jobEntry.getFirstMails() != null)
				wFirstmails.setText(jobEntry.getFirstMails());

			wDelete.setSelection(jobEntry.getDelete());
			wProtocol.setText(jobEntry.getProtocol());
			wIMAPListmails.setText(MailConnectionMeta.getValueImapListDesc(jobEntry.getValueImapList()));
			if(jobEntry.getIMAPFolder()!=null) wIMAPFolder.setText(jobEntry.getIMAPFolder());
			// search term
			if(jobEntry.getSenderSearchTerm()!=null) wSender.setText(jobEntry.getSenderSearchTerm());
			wNegateSender.setSelection(jobEntry.isNotTermSenderSearch());
			if(jobEntry.getReceipientSearch()!=null) wReceipient.setText(jobEntry.getReceipientSearch());
			wNegateReceipient.setSelection(jobEntry.isNotTermReceipientSearch());
			if(jobEntry.getSubjectSearch()!=null) wSubject.setText(jobEntry.getSubjectSearch());
			wNegateSubject.setSelection(jobEntry.isNotTermSubjectSearch());
			if(jobEntry.getBodySearch()!=null) wBody.setText(jobEntry.getBodySearch());
			wNegateBody.setSelection(jobEntry.isNotTermBodySearch());
			wConditionOnReceivedDate.setText(MailConnectionMeta.getConditionDateDesc(jobEntry.getConditionOnReceivedDate()));
			wNegateReceivedDate.setSelection(jobEntry.isNotTermReceivedDateSearch());
			if(jobEntry.getReceivedDate1()!=null) wReadFrom.setText(jobEntry.getReceivedDate1());
			if(jobEntry.getReceivedDate2()!=null) wReadTo.setText(jobEntry.getReceivedDate2());
			wActionType.setText(MailConnectionMeta.getActionTypeDesc(jobEntry.getActionType()));
			wcreateMoveToFolder.setSelection(jobEntry.isCreateMoveToFolder());
			wcreateLocalFolder.setSelection(jobEntry.isCreateLocalFolder());
			if (jobEntry.getMoveToIMAPFolder() != null)
				wMoveToFolder.setText(jobEntry.getMoveToIMAPFolder());
			wAfterGetIMAP.setText(MailConnectionMeta.getAfterGetIMAPDesc(jobEntry.getAfterGetIMAP()));
			wIncludeSubFolders.setSelection(jobEntry.isIncludeSubFolders());
			wUseProxy.setSelection(jobEntry.isUseProxy());
			if(jobEntry.getProxyUsername()!=null) wProxyUsername.setText(jobEntry.getProxyUsername());
	    }

	    private void cancel()
	    {
	        jobEntry.setChanged(changed);
	        jobEntry = null;
	        dispose();
	    }

	    private void ok()
	    {
	        if(Const.isEmpty(wName.getText())) 
	        {
				MessageBox mb = new MessageBox(shell, SWT.OK | SWT.ICON_ERROR );
				mb.setMessage("Veuillez svp donner un nom � cette entr�e t�che!");
				mb.setText("Entr�e t�che non nomm�e");
				mb.open(); 
				return;
	        }
	        jobEntry.setName(wName.getText());
	        jobEntry.setServerName(wServerName.getText());
			jobEntry.setUserName(wUserName.getText());
			jobEntry.setPassword(wPassword.getText());
			jobEntry.setUseSSL(wUseSSL.getSelection());
			jobEntry.setSaveAttachment(wGetAttachment.getSelection());
			jobEntry.setSaveMessage(wGetMessage.getSelection());
			jobEntry.setDifferentFolderForAttachment(wDifferentFolderForAttachment.getSelection());
			jobEntry.setAttachmentFolder(wAttachmentFolder.getText());
			jobEntry.setPort(wPort.getText());
			jobEntry.setOutputDirectory(wOutputDirectory.getText());
			jobEntry.setFilenamePattern(wFilenamePattern.getText());
			jobEntry.setRetrievemails(wListmails.getSelectionIndex());
			jobEntry.setFirstMails(wFirstmails.getText());
			jobEntry.setDelete(wDelete.getSelection());
	        jobEntry.setProtocol(wProtocol.getText());
	        jobEntry.setAttachmentWildcard(wAttachmentWildcard.getText());
	        jobEntry.setValueImapList(MailConnectionMeta.getValueImapListByDesc(wIMAPListmails.getText()));
	        jobEntry.setFirstIMAPMails(wIMAPFirstmails.getText());
	        jobEntry.setIMAPFolder(wIMAPFolder.getText());
	        // search term
	        jobEntry.setSenderSearchTerm(wSender.getText());
	        jobEntry.setNotTermSenderSearch(wNegateSender.getSelection());
	        
	        jobEntry.setReceipientSearch(wReceipient.getText());
	        jobEntry.setNotTermReceipientSearch(wNegateReceipient.getSelection());
	        jobEntry.setSubjectSearch(wSubject.getText());
	        jobEntry.setNotTermSubjectSearch(wNegateSubject.getSelection());
	        jobEntry.setBodySearch(wBody.getText());
	        jobEntry.setNotTermBodySearch(wNegateBody.getSelection());
	        jobEntry.setConditionOnReceivedDate(MailConnectionMeta.getConditionDateByDesc(wConditionOnReceivedDate.getText()));
	        jobEntry.setNotTermReceivedDateSearch(wNegateReceivedDate.getSelection());
	        jobEntry.setReceivedDate1(wReadFrom.getText());
	        jobEntry.setReceivedDate2(wReadTo.getText());
	        jobEntry.setActionType(MailConnectionMeta.getActionTypeByDesc(wActionType.getText()));
	        jobEntry.setMoveToIMAPFolder(wMoveToFolder.getText());
	        jobEntry.setCreateMoveToFolder(wcreateMoveToFolder.getSelection());
	        jobEntry.setCreateLocalFolder(wcreateLocalFolder.getSelection());
	        jobEntry.setAfterGetIMAP(MailConnectionMeta.getAfterGetIMAPByDesc(wAfterGetIMAP.getText()));
	        jobEntry.setIncludeSubFolders(wIncludeSubFolders.getSelection());
	        jobEntry.setUseProxy(wUseProxy.getSelection());
	        jobEntry.setProxyUsername(wProxyUsername.getText());
	        dispose();
	    }

	    public String toString()
	    {
	        return this.getClass().getName();
	    }

	    public boolean evaluates()
	    {
	        return true;
	    }

	    public boolean isUnconditional()
	    {
	        return false;
	    }
}